home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / CIncludes / OpenTptSerial.h < prev    next >
C/C++ Source or Header  |  1996-05-01  |  8KB  |  265 lines
  1. /*
  2.     File:        OpenTptSerial.h
  3.  
  4.     Contains:    Definitions for Serial Port
  5.  
  6.     Copyright:    © 1993-1995 by Apple Computer, Inc., all rights reserved.
  7.  
  8.  
  9. */
  10.  
  11. #ifndef __OPENTPTSERIAL__
  12. #define __OPENTPTSERIAL__
  13.  
  14. #ifndef __OPENTRANSPORT__
  15. #include <OpenTransport.h>
  16. #endif
  17. /*******************************************************************************
  18. ** Module Definitions
  19. ********************************************************************************/
  20. //
  21. // XTI Level
  22. //
  23.  
  24. enum
  25. {
  26.     COM_SERIAL    = 'SERL'
  27. };
  28. //
  29. // Version Number
  30. //
  31. #define kSerialABVersion    "1.0"
  32.  
  33. //
  34. // Module Names
  35. //
  36. #define kSerialABName        "serialAB"
  37. #define kSerialName            "serial"
  38. #define kSerialPortAName    "serialA"
  39. #define kSerialPortBName    "serialB"
  40.  
  41. enum
  42. {
  43.     kSerialABModuleID    = 7200
  44. };
  45.  
  46. enum
  47. {
  48.     kOTSerialFramingAsync            = 0x01,        /* Support Async serial mode             */
  49.     kOTSerialFramingHDLC            = 0x02,        /* Support HDLC synchronous serial mode    */
  50.     kOTSerialFramingSDLC            = 0x04,        /* Support SDLC synchronous serial mode    */
  51.     kOTSerialFramingAsyncPackets    = 0x08         /* Support Async "packet" serial mode    */
  52. };
  53.  
  54. /*******************************************************************************
  55. ** IOCTL Calls for Serial Drivers
  56. ********************************************************************************/
  57.  
  58. enum
  59. {
  60.     /* 
  61.      * Set DTR (0 = off, 1 = on)
  62.      */
  63.     I_SetSerialDTR            = MIOC_CMD(MIOC_SRL, 0),
  64.         kOTSerialSetDTROff            = 0,
  65.         kOTSerialSetDTROn            = 1,
  66.     /*
  67.      * Send a break on the line - kOTSerialSetBreakOff = off, kOTSerialSetBreakOn = on,
  68.      * Any other number is the number of milliseconds to leave break on, then
  69.      * auto shutoff
  70.      */
  71.     I_SetSerialBreak        = MIOC_CMD(MIOC_SRL, 1),
  72.         kOTSerialSetBreakOn        = 0xffffffff,
  73.         kOTSerialSetBreakOff    = 0,
  74.     /*
  75.      * Force XOFF state - 0 = Unconditionally clear XOFF state, 1 = unconditionally set it
  76.      */
  77.     I_SetSerialXOffState    = MIOC_CMD(MIOC_SRL, 2),
  78.         kOTSerialForceXOffTrue        = 1,
  79.         kOTSerialForceXOffFalse        = 0,
  80.     /*
  81.      * Send an XON character
  82.      * 0 = send only if in XOFF state, 1 = send always
  83.      */
  84.     I_SetSerialXOn            = MIOC_CMD(MIOC_SRL, 3),
  85.         kOTSerialSendXOnAlways        = 1,
  86.         kOTSerialSendXOnIfXOffTrue    = 0,
  87.     /*
  88.      * Send an XOFF character
  89.      * 0 = send only if in XON state, 1 = send always
  90.      */
  91.     I_SetSerialXOff            = MIOC_CMD(MIOC_SRL, 4),
  92.         kOTSerialSendXOffAlways        = 1,
  93.         kOTSerialSendXOffIfXOnTrue    = 0
  94. };
  95.  
  96. /*******************************************************************************
  97. ** Option Management for Serial Drivers
  98. ********************************************************************************/
  99. /*
  100. ** These options are all 4-byte values.
  101. ** BaudRate is the baud rate.
  102. ** DataBits is the number of data bits.
  103. ** StopBits is the number of stop bits times 10.
  104. ** Parity is an enum
  105. */
  106.  
  107. enum 
  108. {
  109.     SERIAL_OPT_BAUDRATE    = 0x0100,    /* UInt32    */
  110.     SERIAL_OPT_DATABITS    = 0x0101,    /* UInt32    */
  111.     SERIAL_OPT_STOPBITS    = 0x0102,    /* UInt32 10, 15 or 20 for 1, 1.5 or 2    */
  112.     SERIAL_OPT_PARITY    = 0x0103    /* UInt32    */
  113. };
  114.  
  115.     enum ParityOptionValues
  116.     {
  117.         kOTSerialNoParity = 0, kOTSerialOddParity = 1, kOTSerialEvenParity = 2
  118.     };
  119.  
  120. //
  121. // The "Status" option is a 4-byte value option that is ReadOnly
  122. // It returns a bitmap of the current serial status
  123. //
  124. enum
  125. {
  126.     SERIAL_OPT_STATUS = 0x0104,
  127.     
  128.     kOTSerialSwOverRunErr    = 0x01,
  129.     kOTSerialBreakOn        = 0x08,
  130.     kOTSerialParityErr        = 0x10,
  131.     kOTSerialOverrunErr        = 0x20,
  132.     kOTSerialFramingErr        = 0x40,
  133.     kOTSerialXOffSent        = 0x0010000,
  134.     kOTSerialDTRNegated        = 0x0020000,
  135.     kOTSerialCTLHold        = 0x0040000,
  136.     kOTSerialXOffHold        = 0x0080000,
  137.     kOTSerialOutputBreakOn    = 0x1000000
  138. };
  139.  
  140. //
  141. // The "Handshake" option defines what kind of handshaking the serial port
  142. // will do for line flow control.  The value is a 32-bit value defined by
  143. // the function or macro SerialHandshakeData below.
  144. // For no handshake, or CTS handshake, the onChar and offChar parameters
  145. // are ignored.
  146. //
  147. enum
  148. { 
  149.     SERIAL_OPT_HANDSHAKE = 0x0105
  150. };
  151. //
  152. // These are bits to enable specific types of handshaking
  153. //
  154. enum
  155. {
  156.     kOTSerialXOnOffInputHandshake    = 1,    /* Want XOn/XOff handshake for incoming characters    */
  157.     kOTSerialXOnOffOutputHandshake    = 2,    /* Want XOn/XOff handshake for outgoing characters    */
  158.     kOTSerialCTSInputHandshake        = 4,    /* Want CTS handshake for incoming characters        */
  159.     kOTSerialDTROutputHandshake        = 8        /* Want DTR handshake for outoing characters        */
  160. };
  161.  
  162. #ifdef __cplusplus
  163.  
  164. inline UInt32 OTSerialHandshakeData(UInt16 type, UInt8 onChar, UInt8 offChar)
  165. {
  166.     return (((UInt32)type) << 16) | (((UInt32)onChar) << 8) | offChar;
  167. }
  168.  
  169. #else
  170.  
  171. #define OTSerialHandshakeData(type, onChar, offChar)    \
  172.     ((((UInt32)type) << 16) | (((UInt32)onChar) << 8) | offChar)
  173.     
  174. #endif
  175. //
  176. // The "RcvTimeout" option defines how long the receiver should wait before delivering
  177. // less than the RcvLoWat number of characters.  If RcvLoWat is 0, then the RcvTimeout
  178. // is how long a gap to wait for before delivering characters.  This parameter is advisory,
  179. // and serial drivers are free to deliver data whenever they deem it convenient.  For instance,
  180. // many serial drivers will deliver data whenever 64 bytes have been received, since 64 bytes
  181. // is the smallest STREAMS buffer size. Keep in mind that timeouts are quantized, so be sure to
  182. // look at the return value of the option to determine what it was negotiated to.
  183. //
  184. enum
  185. { 
  186.     SERIAL_OPT_RCVTIMEOUT = 0x0106
  187. };
  188. //
  189. // This option defines how characters with parity errors are handled.
  190. // A 0 value will disable all replacement.  A single character value in the low
  191. // byte designates the replacement character.  When characters are received with a 
  192. // parity error, they are replaced by this specified character.  If a valid incoming
  193. // character matches the replacement character, then the received character's msb is
  194. // cleared. For this situation, the alternate character is used, if specified in bits
  195. // 8 through 15 of the option long, with 0xff being place in bits 16 through 23.
  196. // Whenever a valid character is received that matches the first replacement character,
  197. // it is replaced with this alternate character.
  198. //
  199. enum
  200. { 
  201.     SERIAL_OPT_ERRORCHARACTER = 0x0107
  202. };
  203.  
  204. #ifdef __cplusplus
  205.  
  206. inline UInt32 OTSerialSetErrorCharacter(UInt8 rep)
  207. {
  208.     return rep & 0xff;
  209. }
  210.  
  211. inline UInt32 OTSerialSetErrorCharacterWithAlternate(UInt8 rep, UInt8 alternate)
  212. {
  213.     return (((rep & 0xff) | ((alternate & 0xff) << 8)) | 0x80000000L);
  214. }
  215.  
  216. #else
  217.  
  218. #define OTSerialSetErrorCharacter(rep)    \
  219.     ((rep) & 0xff)
  220.  
  221. #define OTSerialSetErrorCharacterWithAlternate(rep, alternate)    \
  222.     ((((rep) & 0xff) | (((alternate) & 0xff) << 8)) | 0x80000000L)
  223.  
  224. #endif
  225. //
  226. // The "ExtClock" requests an external clock.  A 0-value turns off external clocking.
  227. // Any other value is a requested divisor for the external clock.  Be aware that
  228. // not all serial implementations support an external clock, and that not all
  229. // requested divisors will be supported if it does support an external clock.
  230. //
  231. enum
  232. { 
  233.     SERIAL_OPT_EXTCLOCK = 0x0108
  234. };
  235. //
  236. // The "BurstMode" option informs the serial driver that it should continue looping,
  237. // reading incoming characters, rather than waiting for an interrupt for each character.
  238. // This option may not be supported by all Serial driver
  239. //
  240. enum
  241. { 
  242.     SERIAL_OPT_BURSTMODE = 0x0109
  243. };
  244.  
  245. //
  246. // Default attributes for the serial ports
  247. //
  248. enum
  249. {
  250.     kOTSerialDefaultBaudRate        = 19200,
  251.     kOTSerialDefaultDataBits        = 8,
  252.     kOTSerialDefaultStopBits        = 10,
  253.     kOTSerialDefaultParity            = kOTSerialNoParity,
  254.     kOTSerialDefaultHandshake        = 0,
  255.     kOTSerialDefaultOnChar            = ('Q' & ~0x40),
  256.     kOTSerialDefaultOffChar        = ('S' & ~0x40),
  257.     kOTSerialDefaultSndBufSize        = 128,
  258.     kOTSerialDefaultRcvBufSize        = 128,
  259.     kOTSerialDefaultSndLoWat        = 96,
  260.     kOTSerialDefaultRcvLoWat        = 1,
  261.     kOTSerialDefaultRcvTimeout        = 10
  262. };
  263.  
  264. #endif    /* __OPENTPTSERIAL */
  265.